"""
* P2249 【深基13.例1】查找
* 这是一道二分查找题
* 二分查找是需要细分上下取整的，这个是有模板的，需要细分，具体的需要参考项目中的算法相关笔记！！！！
* |但是，有一定的其他条件的限制。
* 原题中给定的数列是单调不减的，
* 即可能存在重复的数字，对于重复的数字，要求输出这个数字在序列中第一次出现的编号
"""

"""
* resolution1最后过不了judge，具体原因未知，可能是使用递归方式的二分查找写法写错了。
* -> 最早的写法之所以没办法过是因为输出的格式控制错了，它要求的是空格来分割，而不是换行输出！
* 但是可惜的是最后的一个测试点还是因为超时而没办法通过，可能使用递归的方式效率还是会比较低。
"""


def resolution1():
    n, m = map(int, input().split())
    # 构建原始数组,元素编号从1开始，0号用0填充
    # -> 原始序列在给定的时候就是【单调不减】的
    origin_array = [0]
    origin_array.extend(list(map(int, input().split())))
    # 进行二分查询，查询指定数字的编号
    selected_array = list(map(int, input().split()))
    left = 1
    right = n
    for item in selected_array:
        if item == selected_array[-1]:
            print(binary_search(item, origin_array, left, right))
        else:
            print(binary_search(item, origin_array, left, right), end=" ")


"""
* 对于有返回值的递归函数来说，应该使得函数的每一个分支都有它应该返回的返回值！
"""


def binary_search(item, origin_array, left, right):
    mid = int((left+right)/2)
    if left == right and origin_array[mid] != item:
        return -1
    if origin_array[mid] == item:
        # 查找重复数字的第一次出现的编号,得注意这里mid > 1因为我们的编号是从1开始。
        while mid > 1 and origin_array[mid-1] == item:
            mid -= 1
        return mid
    elif origin_array[mid] > item:
        return binary_search(item, origin_array, left, mid)
    elif origin_array[mid] < item:
        return binary_search(item, origin_array, mid+1, right)


def resolution2():
    x, y = map(int, input().split())
    # 构建原始数组,元素编号从1开始，0号用0填充
    # -> 原始序列在给定的时候就是【单调不减】的
    origin_array = [0]
    origin_array.extend(list(map(int, input().split())))
    # 进行二分查询，查询指定数字的编号
    selected_array = list(map(int, input().split()))
    left = 1
    right = x
    for item in selected_array:
        if item == selected_array[-1]:
            print(_binary_search(item, origin_array, left, right))
        else:
            print(_binary_search(item, origin_array, left, right), end=" ")

def _binary_search(item, origin_array, left, right):
    while left <= right:
        mid = int((left + right) / 2)
        if origin_array[mid] == item:
            # 查找重复数字的第一次出现的编号,得注意这里mid > 1因为我们的编号是从1开始。
            while mid > 1 and origin_array[mid - 1] == item:
                mid -= 1
            return mid
        elif origin_array[mid] > item:
            right = mid - 1
        else:
            left = mid + 1
    return -1


def resolution3():
    a, b = map(int, input().split())
    # 构建原始数组,元素编号从1开始，0号用0填充
    # -> 原始序列在给定的时候就是【单调不减】的
    origin_array = [0]
    origin_array.extend(list(map(int, input().split())))
    # 进行二分查询，查询指定数字的编号
    selected_array = list(map(int, input().split()))
    left = 1
    right = a
    for item in selected_array:
        if item == selected_array[-1]:
            print(__binary_search(item, origin_array, left, right))
        else:
            print(__binary_search(item, origin_array, left, right), end=" ")


def __binary_search(item, origin_array, left, right):
    # mid = int((left + right) / 2)
    # if left == right and origin_array[mid] != item:
    #     return -1
    # # 如果要找最先出现的，那程序的出口就必须改变，找最左边
    # if origin_array[left] == item:
    #     return left
    # elif origin_array[mid] >= item:
    #     return __binary_search(item, origin_array, left, mid)
    # elif origin_array[mid] < item:
    #     return __binary_search(item, origin_array, mid + 1, right)
    mid = int((left + right) / 2)
    # 这里才是本题真正的递归出口，因为我们要找的是最先出现的
    if left == right:
        if origin_array[mid] != item:
            return -1
        # 如果要找最先出现的，那程序的出口就必须改变，找最左边
        elif origin_array[mid] == item:
            return mid
    # 如果要找最先出现的，那么对于mid值等于item的情况还要继续往左边找，找最后出现的则是得往右边找
    if origin_array[mid] >= item:
        return __binary_search(item, origin_array, left, mid)
    elif origin_array[mid] < item:
        return __binary_search(item, origin_array, mid + 1, right)


def resolution4():
    c, d = map(int, input().split())
    # 构建原始数组,元素编号从1开始，0号用0填充
    # -> 原始序列在给定的时候就是【单调不减】的
    origin_array = [0]
    origin_array.extend(list(map(int, input().split())))
    # 进行二分查询，查询指定数字的编号
    selected_array = list(map(int, input().split()))
    left = 1
    right = c
    for item in selected_array:
        if item == selected_array[-1]:
            print(___binary_search(item, origin_array, left, right))
        else:
            print(___binary_search(item, origin_array, left, right), end=" ")


def ___binary_search(item, origin_array, left, right):
    while left < right:
        mid = int((left + right) / 2)
        if origin_array[mid] >= item:
            right = mid
        else:
            left = mid + 1
    if origin_array[left] == item:  # left = mid = right
        # 查找重复数字的第一次出现的编号
        return left  # left = mid = right
    return -1


if __name__ == '__main__':
    # 递归二分，洛谷最后一个测试点超时。
    # resolution1()
    # 非递归式二分法,洛谷最后一个测试点超时。
    # resolution2()
    """
    以上这两种解法都出了问题的话，说明真正影响效率的地方并不是在递归或者非递归上，
    综合来看，应该是因为在分支中加了一个循环，所以使得算法的时间复杂度极具增加了。
    以3和4的解法为准。
    """
    # 递归，但是不使用循环，用来比较的值换成了看left
    # resolution3()
    # 非递归，但是用来比较的值换成了left
    resolution4()
